//
//  CouponSelectionConfig.swift
//  CMB250716
//
//  Created by Assistant on 2024-12-19.
//

import SwiftUI

/// 优惠券选择界面的配置参数
struct CouponSelectionConfig {
    
    // MARK: - 卡片尺寸配置
    struct CardDimensions {
        /// 优惠券卡片高度
        static let couponCardHeight: CGFloat = 90
        
        /// 卡片圆角半径
        static let cornerRadius: CGFloat = 15
        
        /// 卡片间距
        static let cardSpacing: CGFloat = 12
        
        /// 卡片内边距
        static let cardPadding: CGFloat = 14
        
        /// 右侧选择区域宽度
        static let selectionAreaWidth: CGFloat = 90
    }
    
    // MARK: - 选中状态样式配置
    struct SelectedStyle {
        /// 选中边框颜色（黑金亮色）
        static let borderColor = Color(red: 1.0, green: 0.84, blue: 0.0) // 金色
        
        /// 选中边框宽度
        static let borderWidth: CGFloat = 3
        
        /// 光晕效果颜色
        static let glowColor = Color(red: 1.0, green: 0.84, blue: 0.0).opacity(0.6)
        
        /// 光晕半径
        static let glowRadius: CGFloat = 8
        
        /// 内部光晕颜色
        static let innerGlowColor = Color(red: 1.0, green: 0.9, blue: 0.3).opacity(0.3)
        
        /// 内部光晕半径
        static let innerGlowRadius: CGFloat = 4
    }
    
    // MARK: - 未选中状态样式配置
    struct UnselectedStyle {
        /// 默认边框颜色
        static let borderColor = Color.white.opacity(0.3)
        
        /// 默认边框宽度
        static let borderWidth: CGFloat = 1
    }
    
    // MARK: - 字体配置
    struct Typography {
        /// 标签字体
        static let tagFont = Font.caption2
        
        /// 标题字体
        static let titleFont = Font.subheadline
        
        /// 描述字体
        static let descriptionFont = Font.caption
        
        /// 有效期字体
        static let validityFont = Font.caption2
        
        /// 右侧价值字体
        static let valueFont = Font.title3
    }
    
    // MARK: - 颜色配置
    struct Colors {
        /// 主要文本颜色
        static let primaryText = Color.white
        
        /// 次要文本颜色
        static let secondaryText = Color.white.opacity(0.9)
        
        /// 辅助文本颜色
        static let tertiaryText = Color.white.opacity(0.8)
        
        /// 选中图标颜色
        static let selectedIcon = Color.white
        
        /// 未选中图标颜色
        static let unselectedIcon = Color.white.opacity(0.6)
    }
    
    // MARK: - 过滤配置
    struct FilterSettings {
        /// 是否只显示可用的优惠券
        static let showOnlyAvailableCoupons = true
        
        /// 是否检查时间限制
        static let checkTimeRestrictions = true
        
        /// 是否检查使用状态
        static let checkUsageStatus = true
        
        /// 是否检查会员等级要求
        static let checkMembershipLevel = true
        
        /// 是否检查最低消费要求
        static let checkMinimumSpend = true
        
        /// 是否检查使用次数限制
        static let checkUsageLimits = true
        
        /// 是否检查使用频率限制
        static let checkUsageFrequency = true
        
        /// 是否在Cart的Select Coupon中过滤营业时间（Limited Coupons和My Coupons不受此影响）
        static let filterBusinessHoursInCartSelection = true
    }
    
    // MARK: - 布局配置
    struct Layout {
        /// Valid until 行与上一行的行距
        static let validUntilLineSpacing: CGFloat = 3
        
        /// 卡片内容的默认行距
        static let defaultLineSpacing: CGFloat = 2
    }
    
    // MARK: - 多语言配置
    struct Localization {
        /// 获取本地化的优惠券标题
        static func getCouponTitle(coupon: Coupon, language: String) -> String {
            guard let couponData = CouponConfig.coupons.first(where: { $0.code == coupon.code }) else {
                return coupon.title
            }
            
            return language == "en" ? couponData.englishTitle : couponData.title
        }
        
        /// 获取本地化的优惠券描述
        static func getCouponDescription(coupon: Coupon, language: String) -> String {
            guard let couponData = CouponConfig.coupons.first(where: { $0.code == coupon.code }) else {
                return coupon.description
            }
            
            return language == "en" ? couponData.englishDescription : couponData.description
        }
        
        /// 获取本地化的"Valid until"文本
        static func getValidUntilText(language: String) -> String {
            return language == "en" ? "Valid until" : "有效期至"
        }
    }
    
    // MARK: - 动画配置
    struct Animation {
        /// 选中状态切换动画时长
        static let selectionDuration: Double = 0.3
        
        /// 光晕动画时长
        static let glowDuration: Double = 1.5
        
        /// 弹性动画参数
        static let springResponse: Double = 0.6
        static let springDamping: Double = 0.8
    }
}

// MARK: - 优惠券过滤扩展
extension CouponSelectionConfig {
    
    /// 检查优惠券是否应该显示在选择列表中
    /// - Parameters:
    ///   - coupon: 要检查的优惠券
    ///   - dataManager: 数据管理器
    ///   - isCartSelection: 是否在Cart的Select Coupon中调用（默认false，用于Limited Coupons和My Coupons）
    static func shouldShowCoupon(_ coupon: Coupon, dataManager: DataManager, isCartSelection: Bool = false) -> Bool {
        guard FilterSettings.showOnlyAvailableCoupons else {
            return coupon.isValid
        }
        
        // 基础有效性检查
        guard coupon.isValid else { return false }
        
        // 检查现金券的特殊显示逻辑（仅在非购物车选择时应用，购物车选择时在后面统一处理）
        if !isCartSelection && coupon.code.hasPrefix("CASH_VOUCHER_") {
            // 现金券只有在用户拥有时才显示
            guard let user = dataManager.currentUser else { return false }
            return user.ownedCoupons.contains { userCoupon in
                userCoupon.couponCode == coupon.code && !userCoupon.isUsed && userCoupon.expiryDate > Date()
            }
        }
        
        // 在购物车选择时，对于现金券需要特殊处理：先检查用户是否拥有，再检查最低消费
        if isCartSelection && coupon.code.hasPrefix("CASH_VOUCHER_") {
            // 检查用户是否拥有此现金券
            guard let user = dataManager.currentUser,
                  user.ownedCoupons.contains(where: { $0.couponCode == coupon.code && !$0.isUsed && $0.expiryDate > Date() }) else {
                return false
            }
            // 现金券如果用户拥有，则跳过解锁条件检查，直接进行后续的最低消费检查
        } else if isCartSelection {
            // 对于非现金券，应用完整的解锁条件检查
            let unlockCondition = CouponConfig.UnlockConditions.getUnlockConditionType(
                for: coupon.code,
                user: dataManager.currentUser,
                dataManager: dataManager
            )
            
            // 如果有任何限制条件，则不显示
            if unlockCondition != .none {
                return false
            }
        }
        
        // 检查使用频率限制（特别是周频率优惠券）
        if FilterSettings.checkUsageFrequency, let user = dataManager.currentUser {
            // 对于周频率优惠券，在购物车选择时检查本周是否已使用
            if coupon.usageFrequency == .weekly && isCartSelection {
                let calendar = Calendar.current
                guard let currentWeekInterval = calendar.dateInterval(of: .weekOfYear, for: Date()) else {
                    return true
                }
                
                // 检查本周是否已使用过此优惠券
                let usedThisWeek = user.couponUsageHistory.contains { record in
                    record.couponCode == coupon.code &&
                    currentWeekInterval.contains(record.usedDate)
                }
                
                // 如果本周已使用，则在购物车选择时不显示
                if usedThisWeek {
                    return false
                }
            }
        }
        
        // 在Cart的Select Coupon中额外检查营业时间
        if isCartSelection && FilterSettings.filterBusinessHoursInCartSelection {
            // 检查当前是否在营业时间内
            if !BusinessHoursManager.isWithinBusinessHours() {
                // 检查优惠券是否有时间限制，如果有且当前不在适用时间内，则不显示
                if !coupon.isApplicableAtCurrentTime() {
                    return false
                }
            }
        }
        
        // 检查最低消费（只在购物车选择时应用，且购物车不为空）
        if isCartSelection && FilterSettings.checkMinimumSpend && !dataManager.cartItems.isEmpty {
            // 计算非现金券商品的总价（用于最低消费验证）
            let nonCashVoucherTotal = dataManager.cartItems
                .filter { $0.menuItem.name != AppConfig.Cart.voucherPackageName }
                .reduce(0) { $0 + $1.totalPrice }
            
            // 检查是否满足最低消费要求（现金券的拥有检查已在前面完成）
            if nonCashVoucherTotal < coupon.minimumSpend {
                return false
            }
        }
        
        // 检查特定优惠券的商品要求（只在购物车选择时应用）
        if isCartSelection {
            return checkSpecificCouponRequirements(coupon, dataManager: dataManager)
        }
        
        return true
    }
    
    /// 检查特定优惠券的商品要求
    private static func checkSpecificCouponRequirements(_ coupon: Coupon, dataManager: DataManager) -> Bool {
        switch coupon.code {
        case "HIGHBALL":
            // 检查是否有Highball商品
            let hasHighball = dataManager.cartItems.contains { $0.menuItem.name == "Highball" }
            if !hasHighball {
                return false
            }
            
            // 检查非酒水类菜品是否达到S$20
            let nonAlcoholicTotal = dataManager.cartItems
                .filter { item in
                    item.menuItem.name != AppConfig.Cart.voucherPackageName &&
                    !(item.menuItem.category == .drinks && item.menuItem.drinkType == .alcoholic)
                }
                .reduce(0) { $0 + $1.totalPrice }
            
            return nonAlcoholicTotal >= 20.0
            
        case "CALFCOFFEE":
            // 检查是否有指定咖啡（Americano/Latte/Cappuccino）
            let hasEligibleCoffee = dataManager.cartItems.contains { item in
                item.menuItem.name == "美式咖啡" ||
                item.menuItem.name == "Americano" ||
                item.menuItem.name == "拿铁咖啡" ||
                item.menuItem.name == "Caffe Latte" ||
                item.menuItem.name == "卡布奇诺" ||
                item.menuItem.name == "Cappuccino"
            }
            if !hasEligibleCoffee {
                return false
            }
            
            // 检查非饮品类菜品是否达到S$10
            let nonDrinkTotal = dataManager.cartItems
                .filter { item in
                    item.menuItem.name != AppConfig.Cart.voucherPackageName &&
                    item.menuItem.category != .drinks
                }
                .reduce(0) { $0 + $1.totalPrice }
            
            return nonDrinkTotal >= 10.0
            
        default:
            return true
        }
    }
    
    /// 获取用户优惠券使用次数（私有辅助方法）
    private static func getUserCouponUsageCount(couponCode: String, user: User, usageFrequency: UsageFrequency) -> Int {
        let calendar = Calendar.current
        let now = Date()
        
        switch usageFrequency {
        case .once:
            // 终身只能使用一次
            return user.couponUsageHistory.filter { $0.couponCode == couponCode }.count
            
        case .daily:
            // 每日限用一次
            let startOfDay = calendar.startOfDay(for: now)
            return user.couponUsageHistory.filter { record in
                record.couponCode == couponCode &&
                record.usedDate >= startOfDay
            }.count
            
        case .weekly:
            // 每周限用一次
            let startOfWeek = calendar.dateInterval(of: .weekOfYear, for: now)?.start ?? now
            return user.couponUsageHistory.filter { record in
                record.couponCode == couponCode &&
                record.usedDate >= startOfWeek
            }.count
            
        case .monthly:
            // 每月限用一次
            let startOfMonth = calendar.dateInterval(of: .month, for: now)?.start ?? now
            return user.couponUsageHistory.filter { record in
                record.couponCode == couponCode &&
                record.usedDate >= startOfMonth
            }.count
            
        case .yearly:
            // 每年限用一次
            let startOfYear = calendar.dateInterval(of: .year, for: now)?.start ?? now
            return user.couponUsageHistory.filter { record in
                record.couponCode == couponCode &&
                record.usedDate >= startOfYear
            }.count
            
        case .perOrder:
            // 每单限用一次，在购物车中处理限制逻辑
            return 0
        }
    }
}